// 僵尸类 - 修复版本
class Zombie {
    constructor(x, y, type = 'normal', level = 1) {
        this.x = x;
        this.y = y;
        this.type = type;
        this.level = Math.max(1, Math.min(20, level)); // 支持1-20级
        this.radius = 14 + this.level * 2; // 等级越高体型越大
        
        // 安全获取僵尸属性
        const baseStats = this.getZombieStats(type, level);
        const levelMultiplier = this.getLevelMultiplier();
        
        this.health = Math.floor(baseStats.health * levelMultiplier.health);
        this.maxHealth = this.health;
        this.speed = Math.floor(baseStats.speed * levelMultiplier.speed);
        this.damage = Math.floor(baseStats.damage * levelMultiplier.damage);
        this.attackCooldown = Math.max(150, 400 - this.level * 40); // 等级越高攻击越快
        this.lastAttackTime = 0;
        
        // 为新僵尸类型保存完整stats
        if (!['normal', 'fast', 'tank', 'spitter'].includes(type)) {
            this.stats = baseStats;
            console.log(`🧟 创建新类型僵尸: ${type}`, this.stats);
        }
        
        // 等级特性
        this.expReward = this.calculateExpReward();
        this.skillPoints = this.level >= 3 ? 1 : 0;
        
        // AI状态
        this.target = null;
        this.state = 'wandering'; // 'wandering', 'chasing', 'attacking'
        this.detectionRange = 150;
        this.attackRange = 30; // 稍微增加攻击范围
        
        // 动画
        this.animationFrame = 0;
        this.animationTime = 0;
        this.facing = 0;
        
        // 随机徘徊
        this.wanderDirection = Math.random() * Math.PI * 2;
        this.wanderTimer = 0;
        this.wanderInterval = 2000 + Math.random() * 3000;
        
        // 视觉效果
        this.colors = this.getZombieColors(type);
        // this.bloodStains = []; // 禁用血迹效果
        
        // 技能冷却 - 安全初始化
        this.skillCooldowns = {
            charge: 0,
            spit: 0,
            heal: 0,
            explode: 0,
            summon: 0
        };
        
        // 等级视觉特征
        this.glowIntensity = this.level * 0.2;
        this.scaleMultiplier = 1 + (this.level - 1) * 0.1;
        
        // 新僵尸类型特殊属性初始化
        this.initializeSpecialProperties();
    }
    
    getZombieStats(type, level = 1) {
        const stats = {
            // 原有僵尸类型
            'normal': {
                health: 50,
                speed: 80,
                damage: 20,
                color: '#8B7D6B'
            },
            'fast': {
                health: 30,
                speed: 150,
                damage: 15,
                color: '#A0522D'
            },
            'tank': {
                health: 120,
                speed: 50,
                damage: 35,
                color: '#2F4F4F'
            },
            'spitter': {
                health: 40,
                speed: 60,
                damage: 25,
                color: '#6B8E23'
            },
            
            // === 新增僵尸类型（第11-20关） ===
            // 爆炸型僵尸 - 死亡时爆炸伤害周围单位
            'exploder': {
                name: '爆炸僵尸',
                health: 80,
                speed: 80,
                damage: 30,
                color: '#FF4500',
                size: 25,
                explosionRadius: 70, // 减小爆炸范围，提升游戏体验
                explosionDamage: 45, // 适当降低伤害
                special: 'explosion_on_death'
            },
            
            // 电击型僵尸 - 放电攻击
            'electric': {
                name: '电击僵尸',
                health: 100,
                speed: 70,
                damage: 35,
                color: '#00FFFF',
                size: 22,
                electricRange: 120,
                electricDamage: 25,
                electricCooldown: 3000,
                special: 'electric_attack'
            },
            
            // 隐身型僵尸 - 间歇性隐身
            'stealth': {
                name: '隐身僵尸',
                health: 70,
                speed: 120,
                damage: 40,
                color: '#8A2BE2',
                size: 20,
                stealthDuration: 2000,
                stealthCooldown: 5000,
                special: 'stealth_ability'
            },
            
            // 巨型僵尸 - 超大型，极高血量，遵循原有风格
            'giant': {
                name: '巨型僵尸',
                health: 300,
                speed: 40,
                damage: 80,
                color: '#8B7D6B', // 保持原有僵尸色调，稍微调暗
                size: 50,
                special: 'giant_size'
            },
            
            // 分裂型僵尸 - 死亡时分裂成小僵尸
            'splitter': {
                name: '分裂僵尸',
                health: 120,
                speed: 60,
                damage: 25,
                color: '#FF1493',
                size: 30,
                splitCount: 3,
                splitType: 'normal',
                special: 'split_on_death'
            },
            
            // 治愈型僵尸 - 能治愈其他僵尸
            'healer': {
                name: '治愈僵尸',
                health: 90,
                speed: 50,
                damage: 20,
                color: '#32CD32',
                size: 24,
                healRange: 80,
                healAmount: 20,
                healCooldown: 4000,
                special: 'heal_others'
            },
            
            // 狂暴型僵尸 - 血量越低速度越快
            'berserker': {
                name: '狂暴僵尸',
                health: 150,
                speed: 60,
                damage: 50,
                color: '#DC143C',
                size: 28,
                maxSpeedMultiplier: 2.5,
                special: 'berserker_rage'
            }
        };
        
        const baseStats = stats[type] || stats['normal'];
        
        // 根据等级调整属性
        if (level > 1) {
            const levelMultiplier = 1 + (level - 1) * 0.3;
            return {
                ...baseStats,
                health: Math.floor(baseStats.health * levelMultiplier),
                damage: Math.floor(baseStats.damage * levelMultiplier),
                speed: Math.floor(baseStats.speed * Math.min(levelMultiplier, 1.5)) // 速度增长有上限
            };
        }
        
        return baseStats;
    }
    
    // 初始化特殊属性的方法
    initializeSpecialProperties() {
        if (!this.stats || !this.stats.special) return;
        
        // 初始化特殊能力相关的属性
        switch (this.stats.special) {
            case 'electric_attack':
                this.lastElectricAttack = 0;
                break;
                
            case 'stealth_ability':
                this.stealthTimer = Date.now();
                this.isStealthed = false;
                this.alpha = 1;
                break;
                
            case 'berserker_rage':
                this.currentSpeed = this.speed;
                this.currentColor = this.stats.color;
                break;
                
            case 'heal_others':
                this.lastHeal = 0;
                break;
        }
        
        // 如果有特殊大小，更新半径
        if (this.stats.size) {
            this.radius = this.stats.size / 2;
        }
    }
    
    getZombieColors(type) {
        const baseColor = this.getZombieStats(type).color;
        const levelTint = this.getLevelColorTint();
        
        return {
            body: this.blendColors(baseColor, levelTint, this.level * 0.15),
            clothes: this.darkenColor(baseColor, 0.3),
            blood: '#8B0000',
            eyes: this.level >= 3 ? '#FF4500' : '#FF0000', // 高等级僵尸眼睛更亮
            glow: this.level >= 4 ? '#FF6B6B' : null
        };
    }
    
    getLevelMultiplier() {
        const multipliers = {
            1: { health: 1.0, speed: 1.0, damage: 1.0 },
            2: { health: 1.3, speed: 1.1, damage: 1.2 },
            3: { health: 1.6, speed: 1.2, damage: 1.4 },
            4: { health: 2.0, speed: 1.3, damage: 1.7 },
            5: { health: 2.5, speed: 1.5, damage: 2.0 }
        };
        return multipliers[this.level] || multipliers[1];
    }
    
    calculateExpReward() {
        const baseExp = {
            'normal': 10,
            'fast': 15,
            'tank': 25,
            'spitter': 20
        };
        return (baseExp[this.type] || 10) * this.level;
    }
    
    getLevelColorTint() {
        const tints = {
            1: '#FFFFFF', // 无色调
            2: '#FFFFE0', // 淡黄色
            3: '#FFE4B5', // 桃色
            4: '#FFA500', // 橙色
            5: '#FF4500'  // 红橙色
        };
        return tints[this.level] || tints[1];
    }
    
    blendColors(color1, color2, ratio) {
        const hex1 = color1.replace('#', '');
        const hex2 = color2.replace('#', '');
        
        const r1 = parseInt(hex1.substr(0, 2), 16);
        const g1 = parseInt(hex1.substr(2, 2), 16);
        const b1 = parseInt(hex1.substr(4, 2), 16);
        
        const r2 = parseInt(hex2.substr(0, 2), 16);
        const g2 = parseInt(hex2.substr(2, 2), 16);
        const b2 = parseInt(hex2.substr(4, 2), 16);
        
        const r = Math.floor(r1 * (1 - ratio) + r2 * ratio);
        const g = Math.floor(g1 * (1 - ratio) + g2 * ratio);
        const b = Math.floor(b1 * (1 - ratio) + b2 * ratio);
        
        return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
    }
    
    darkenColor(color, factor) {
        const hex = color.replace('#', '');
        const r = Math.floor(parseInt(hex.substr(0, 2), 16) * (1 - factor));
        const g = Math.floor(parseInt(hex.substr(2, 2), 16) * (1 - factor));
        const b = Math.floor(parseInt(hex.substr(4, 2), 16) * (1 - factor));
        return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
    }
    
    update(deltaTime, player) {
        try {
            this.updateAI(deltaTime, player);
            this.updateAnimation(deltaTime);
            // this.updateBloodStains(deltaTime); // 禁用血迹更新
            this.updateSkillCooldowns(deltaTime);
            this.tryUseSpecialAbility(deltaTime, player);
            
            // 处理新僵尸类型的特殊能力
            if (this.stats && this.stats.special) {
                this.updateSpecialAbilities(deltaTime, player);
            }
        } catch (error) {
            console.error('僵尸更新错误:', error);
        }
    }
    
    updateSkillCooldowns(deltaTime) {
        try {
            for (let skill in this.skillCooldowns) {
                if (this.skillCooldowns[skill] > 0) {
                    this.skillCooldowns[skill] -= deltaTime;
                }
            }
        } catch (error) {
            console.error('技能冷却更新错误:', error);
        }
    }
    
    // 修复版本 - 使用特殊技能
    tryUseSpecialAbility(deltaTime, player) {
        try {
            if (!player || this.level < 2) return;
            
            // 安全检查玩家坐标
            if (typeof player.x !== 'number' || typeof player.y !== 'number') {
                console.warn('玩家坐标无效');
                return;
            }
            
            const distToPlayer = Math.sqrt(
                Math.pow(this.x - player.x, 2) + Math.pow(this.y - player.y, 2)
            );
            
            // 检查距离是否有效
            if (isNaN(distToPlayer) || distToPlayer < 0) {
                console.warn('计算距离无效');
                return;
            }
            
            // 第九关需要特殊的性能保护措施
            if (window.gameManager && window.gameManager.levelManager.currentLevel === 9) {
                // 第9关：严格限制投射物数量和频率
                if (window.gameEngine && window.gameEngine.zombieProjectiles && 
                    window.gameEngine.zombieProjectiles.length > 8) {
                    return; // 第9关最多8个投射物
                }
                
                // 额外的随机限制，减少同时发射的概率
                if (Math.random() < 0.7) {
                    return; // 70%的概率不发射，减少密度
                }
            } else if (window.gameManager && window.gameManager.levelManager.currentLevel >= 10) {
                // 第10关及以上：中等限制
                if (window.gameEngine && window.gameEngine.zombieProjectiles && 
                    window.gameEngine.zombieProjectiles.length > 12) {
                    return;
                }
            }
            
            // 根据僵尸类型和等级使用不同技能
            if (this.type === 'fast' && this.level >= 3 && distToPlayer <= 120 && this.skillCooldowns.charge <= 0) {
                this.useChargeAbility(player);
            } else if (this.type === 'spitter' && this.level >= 2 && distToPlayer <= 200 && this.skillCooldowns.spit <= 0) {
                // 对spitter技能添加额外限制
                const currentLevel = window.gameManager ? window.gameManager.levelManager.currentLevel : 1;
                const cooldownTime = currentLevel === 9 ? 3000 : 1500; // 第9关3秒冷却，其他1.5秒
                
                if (this.lastSpitTime && Date.now() - this.lastSpitTime < cooldownTime) {
                    return; 
                }
                this.lastSpitTime = Date.now();
                
                // 添加额外的安全检查
                try {
                    this.useSpitAbility(player);
                } catch (spitError) {
                    console.error('Spitter技能使用失败:', spitError);
                    // 设置更长的冷却时间以防止快速重试
                    this.skillCooldowns.spit = 5000;
                }
            } else if (this.type === 'tank' && this.level >= 4 && this.health < this.maxHealth * 0.3 && this.skillCooldowns.heal <= 0) {
                try {
                    this.useHealAbility();
                } catch (healError) {
                    console.error('治疗技能错误:', healError);
                }
            } else if (this.level >= 5 && this.health < this.maxHealth * 0.2 && this.skillCooldowns.explode <= 0) {
                this.useExplodeAbility(player);
            }
        } catch (error) {
            console.error('使用特殊技能错误:', error);
        }
    }
    
    // 修复版本 - 冲锋技能
    useChargeAbility(player) {
        try {
            this.skillCooldowns.charge = 5000; // 5秒冷却
            
            // 检查玩家是否存在
            if (!player) {
                console.warn('冲锋技能: 玩家不存在');
                return;
            }
            
            // 快速冲锋到玩家位置
            const dx = player.x - this.x;
            const dy = player.y - this.y;
            const distance = Math.sqrt(dx * dx + dy * dy);
            
            if (distance > 0) {
                const chargeSpeed = this.speed * 3;
                const chargeDistance = Math.min(distance, 80);
                
                this.x += (dx / distance) * chargeDistance;
                this.y += (dy / distance) * chargeDistance;
                
                // 冲锋造成额外伤害 - 增加安全检查
                if (distance <= 40 && window.player && typeof window.player.takeDamage === 'function') {
                    try {
                        window.player.takeDamage(this.damage * 1.5);
                        console.log(`${this.level}级快速僵尸使用冲锋攻击！`);
                    } catch (damageError) {
                        console.error('冲锋伤害失败:', damageError);
                    }
                }
            }
        } catch (error) {
            console.error('冲锋技能错误:', error);
        }
    }
    
    // 修复版本 - 吐液技能
    useSpitAbility(player) {
        try {
            this.skillCooldowns.spit = 3000; // 3秒冷却
            
            // 检查玩家和游戏引擎是否存在
            if (!player) {
                console.warn('唾液技能: 玩家不存在');
                return;
            }
            
            if (!window.gameEngine) {
                console.warn('唾液技能: 游戏引擎不存在');
                return;
            }
            
            // 创建腐蚀性唾液弹
            const dx = player.x - this.x;
            const dy = player.y - this.y;
            const distance = Math.sqrt(dx * dx + dy * dy);
            
            if (distance > 0 && !isNaN(distance) && distance < 1000) { // 添加距离合理性检查
                // 验证所有数值的有效性
                if (isNaN(dx) || isNaN(dy) || isNaN(this.x) || isNaN(this.y)) {
                    console.warn('Spitter创建投射物时数据无效');
                    return;
                }
                
                const velocity = 200;
                const normalizedVx = (dx / distance) * velocity;
                const normalizedVy = (dy / distance) * velocity;
                
                // 二次验证速度向量
                if (isNaN(normalizedVx) || isNaN(normalizedVy)) {
                    console.warn('投射物速度计算无效');
                    return;
                }
                
                const spitBullet = {
                    x: Number(this.x),
                    y: Number(this.y),
                    vx: Number(normalizedVx),
                    vy: Number(normalizedVy),
                    damage: Number(this.damage * 0.8) || 15,
                    type: 'spit',
                    radius: 6,
                    life: 2000,
                    maxLife: 2000,
                    color: '#90EE90'
                };
                
                // 最终数据验证
                const isValidData = Object.values(spitBullet).every(val => 
                    typeof val === 'string' || (!isNaN(val) && isFinite(val))
                );
                
                if (!isValidData) {
                    console.error('投射物数据验证失败:', spitBullet);
                    return;
                }
                
                // 使用新的安全投射物系统
                try {
                    if (window.gameEngine && typeof window.gameEngine.addZombieProjectile === 'function') {
                        const success = window.gameEngine.addZombieProjectile(spitBullet);
                        if (success) {
                            console.log(`${this.level}级喷射僵尸发射腐蚀唾液！`);
                        } else {
                            console.warn('投射物添加失败，可能数组已满');
                            // 设置更长的冷却时间
                            this.skillCooldowns.spit = 2000;
                        }
                    } else {
                        console.warn('游戏引擎投射物系统不可用');
                    }
                } catch (projectileError) {
                    console.error('添加僵尸投射物失败:', projectileError);
                    console.error('错误堆栈:', projectileError.stack);
                    // 出错时设置长冷却时间，避免重复错误
                    this.skillCooldowns.spit = 5000;
                }
            } else {
                console.warn(`Spitter投射物创建条件不满足: distance=${distance}, dx=${dx}, dy=${dy}`);
            }
        } catch (error) {
            console.error('唾液技能错误:', error);
        }
    }
    
    // 修复版本 - 治疗技能
    useHealAbility() {
        try {
            this.skillCooldowns.heal = 8000; // 8秒冷却
            
            // 恢复25%血量
            const healAmount = Math.floor(this.maxHealth * 0.25);
            this.health = Math.min(this.maxHealth, this.health + healAmount);
            
            // 创建治疗特效 - 使用安全的特效创建
            try {
                if (typeof this.createHealEffect === 'function') {
                    this.createHealEffect();
                } else {
                    // 简单的绿色粒子特效作为备用
                    this.createSimpleHealParticles();
                }
            } catch (effectError) {
                console.error('治疗特效创建失败:', effectError);
            }
            
            console.log(`${this.level}级坦克僵尸使用再生能力，恢复${healAmount}血量！`);
        } catch (error) {
            console.error('治疗技能错误:', error);
        }
    }
    
    // 修复版本 - 爆炸技能
    useExplodeAbility(player) {
        try {
            this.skillCooldowns.explode = 0; // 只能使用一次
            
            // 检查玩家是否存在
            if (!player) {
                console.warn('爆炸技能: 玩家不存在');
                return;
            }
            
            // 自爆攻击
            const explodeRange = 60 + this.level * 10;
            const dx = player.x - this.x;
            const dy = player.y - this.y;
            const distance = Math.sqrt(dx * dx + dy * dy);
            
            if (distance <= explodeRange) {
                const explosionDamage = this.damage * 2;
                if (window.player && typeof window.player.takeDamage === 'function') {
                    try {
                        window.player.takeDamage(explosionDamage);
                        console.log(`${this.level}级僵尸自爆！造成${explosionDamage}点伤害！`);
                    } catch (damageError) {
                        console.error('爆炸伤害失败:', damageError);
                    }
                }
            }
            
            // 创建爆炸特效 - 使用安全的特效创建
            try {
                if (typeof this.createExplosionEffect === 'function') {
                    this.createExplosionEffect();
                } else {
                    // 简单的红色粒子特效作为备用 - 已禁用红色圆圈效果
                    // this.createSimpleExplosionParticles();
                }
            } catch (effectError) {
                console.error('爆炸特效创建失败:', effectError);
            }
            
            // 自爆后死亡
            this.health = 0;
            try {
                this.die();
            } catch (dieError) {
                console.error('僵尸死亡处理失败:', dieError);
            }
        } catch (error) {
            console.error('爆炸技能错误:', error);
        }
    }
    
    updateAI(deltaTime, player) {
        if (!player) return;
        
        const distToPlayer = Math.sqrt(
            Math.pow(this.x - player.x, 2) + Math.pow(this.y - player.y, 2)
        );
        
        // 状态机
        switch (this.state) {
            case 'wandering':
                this.wander(deltaTime);
                if (distToPlayer <= this.detectionRange) {
                    this.state = 'chasing';
                    this.target = player;
                }
                break;
                
            case 'chasing':
                this.chaseTarget(deltaTime, player);
                if (distToPlayer > this.detectionRange * 1.5) {
                    this.state = 'wandering';
                    this.target = null;
                } else if (distToPlayer <= this.attackRange + 10) { // 扩大进入攻击状态的距离
                    this.state = 'attacking';
                }
                break;
                
            case 'attacking':
                if (distToPlayer > this.attackRange + 15) { // 扩大退出攻击状态的距离
                    this.state = 'chasing';
                } else {
                    // 在攻击状态时，僵尸会持续尝试接近玩家以保持碰撞
                    // 这样游戏引擎的碰撞检测就能持续触发攻击
                    this.chaseTarget(deltaTime * 0.3, player);
                }
                break;
        }
    }
    
    wander(deltaTime) {
        this.wanderTimer += deltaTime;
        
        if (this.wanderTimer >= this.wanderInterval) {
            this.wanderDirection = Math.random() * Math.PI * 2;
            this.wanderTimer = 0;
            this.wanderInterval = 2000 + Math.random() * 3000;
        }
        
        const moveX = Math.cos(this.wanderDirection) * this.speed * 0.3 * deltaTime / 1000;
        const moveY = Math.sin(this.wanderDirection) * this.speed * 0.3 * deltaTime / 1000;
        
        this.x += moveX;
        this.y += moveY;
        
        // 边界检查
        const canvas = document.getElementById('gameCanvas');
        this.x = Math.max(this.radius, Math.min(canvas.width - this.radius, this.x));
        this.y = Math.max(this.radius, Math.min(canvas.height - this.radius, this.y));
    }
    
    chaseTarget(deltaTime, target) {
        const dx = target.x - this.x;
        const dy = target.y - this.y;
        const distance = Math.sqrt(dx * dx + dy * dy);
        
        if (distance > 0) {
            const dirX = dx / distance;
            const dirY = dy / distance;
            
            this.x += dirX * this.speed * deltaTime / 1000;
            this.y += dirY * this.speed * deltaTime / 1000;
            
            this.facing = Math.atan2(dy, dx);
        }
    }
    
    attack(target) {
        if (this.canAttack()) {
            this.lastAttackTime = Date.now();
            // 攻击将在碰撞检测中处理
        }
    }
    
    canAttack() {
        return Date.now() - this.lastAttackTime >= this.attackCooldown;
    }
    
    takeDamage(damage) {
        this.health -= damage;
        // this.addBloodStain(); // 禁用血迹效果
        
        if (this.health <= 0) {
            this.die();
        }
    }
    
    die() {
        try {
            // 给予经验值和技能点奖励
            if (window.weaponEnhancement) {
                window.weaponEnhancement.addExperience(this.expReward);
                if (this.skillPoints > 0) {
                    window.weaponEnhancement.skillPoints += this.skillPoints;
                    console.log(`击杀${this.level}级${this.type}僵尸，获得${this.expReward}经验值和${this.skillPoints}技能点！`);
                }
            }
            
            // 创建死亡特效
            this.createDeathEffect();
        } catch (error) {
            console.error('僵尸死亡处理错误:', error);
        }
    }
    
    createDeathEffect() {
        try {
            if (window.visualEffectsSystem) {
                // 根据等级创建不同强度的死亡特效
                const effectIntensity = this.level;
                window.visualEffectsSystem.createZombieDeathEffect(this.x, this.y, effectIntensity, this.type);
            }
        } catch (error) {
            console.error('死亡特效创建错误:', error);
        }
    }
    
    createHealEffect() {
        try {
            // 简单的治疗光环效果
            if (window.visualEffectsSystem) {
                window.visualEffectsSystem.createHealEffect(this.x, this.y);
            }
        } catch (error) {
            console.error('治疗特效创建错误:', error);
        }
    }
    
    createExplosionEffect() {
        try {
            // 爆炸特效
            if (window.visualEffectsSystem) {
                window.visualEffectsSystem.createExplosionEffect(this.x, this.y, 60 + this.level * 10);
            }
        } catch (error) {
            console.error('爆炸特效创建错误:', error);
        }
    }
    
    addBloodStain() {
        // 血迹效果已禁用
        return;
    }
    
    updateBloodStains(deltaTime) {
        // 血迹效果已禁用
        return;
    }
    
    updateAnimation(deltaTime) {
        this.animationTime += deltaTime;
        if (this.animationTime > 300) {
            this.animationFrame = (this.animationFrame + 1) % 4;
            this.animationTime = 0;
        }
    }
    
    render(ctx) {
        ctx.save();
        ctx.translate(this.x, this.y);
        ctx.scale(this.scaleMultiplier, this.scaleMultiplier);
        
        // 性能优化：根据僵尸数量决定渲染详细程度  
        const zombieCount = window.gameEngine ? window.gameEngine.zombies.length : 0;
        const useSimplifiedRendering = zombieCount > 60; // 僵尸数量超过60时才使用简化渲染，确保11-20关正常显示
        
        if (useSimplifiedRendering) {
            // 简化渲染模式 - 只绘制基本形状和颜色标识
            this.drawSimplifiedZombie(ctx);
        } else {
            // 详细渲染模式
            // 绘制等级光环 (4级以上)
            if (this.level >= 4 && this.colors.glow) {
                this.drawLevelAura(ctx);
            }
            
            // 根据类型绘制僵尸 - 使用正确的方法
            this.drawZombieCorrect(ctx);
            
            // 绘制等级标识
            this.drawLevelIndicator(ctx);
        }
        
        // 绘制血量条 (如果受伤) - 始终显示
        if (this.health < this.maxHealth) {
            this.drawHealthBar(ctx);
        }
        
        // 性能优化：只在非简化模式下绘制额外UI
        if (!useSimplifiedRendering) {
            // 绘制状态指示器
            if (this.state === 'chasing') {
                this.drawAggroIndicator(ctx);
            }
            
            // 绘制技能充能指示器
            this.drawSkillIndicators(ctx);
        }
        
        ctx.restore();
    }
    
    // 简化渲染 - 现在与详细渲染完全一致
    drawSimplifiedZombie(ctx) {
        // 直接使用统一渲染方法，确保完全一致
        this.drawUnifiedZombie(ctx);
    }
    
    // 旧的简化特征方法（已删除）
    drawSimplifiedTypeFeatures_OLD_REMOVED(ctx, size, bodyOffset, sizeMultiplier) {
        console.error('调用了已删除的简化特征方法，请使用drawUnifiedTypeSpecificFeatures');
        return;
        // 以下代码已被禁用
        const halfSize = size / 2;
        
        switch (this.type) {
            case 'giant':
                // 巨大疤痕（保持原有血色风格）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 1 + bodyOffset, size - 8, 2);
                ctx.fillRect(-halfSize + 2, -halfSize + 8 + bodyOffset, size - 4, 2);
                break;
            case 'electric':
                // 电击僵尸 - 与详细渲染保持一致
                ctx.fillStyle = this.darkenColor(this.colors.clothes, 0.4);
                ctx.fillRect(-halfSize + 8, -halfSize + 7 + bodyOffset, 2 * sizeMultiplier, 2);
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 3, -halfSize + 4 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                break;
            case 'stealth':
                // 隐身僵尸 - 与详细渲染保持一致
                if (this.isStealthed) {
                    ctx.globalAlpha = 0.5;
                }
                // 使用深色眼睛标记
                ctx.fillStyle = this.darkenColor(this.colors.eyes, 0.3);
                ctx.fillRect(-halfSize + 5, -halfSize + 2 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                ctx.fillRect(-halfSize + 11 * sizeMultiplier, -halfSize + 2 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                if (this.isStealthed) {
                    ctx.globalAlpha = 1;
                }
                break;
            case 'exploder':
                // 爆炸僵尸 - 与详细渲染保持一致
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 3 + bodyOffset, 8 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 2, -halfSize + 5 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                break;
            case 'splitter':
                // 分裂僵尸 - 与详细渲染保持一致
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 1 + bodyOffset, 2 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 10, -halfSize + 6 + bodyOffset, 3 * sizeMultiplier, 1);
                break;
            case 'healer':
                // 治愈僵尸 - 与详细渲染保持一致（使用绿色）
                ctx.fillStyle = '#228B22'; // 与spitter相同的绿色
                ctx.fillRect(-halfSize + 8, -halfSize + 7 + bodyOffset, 2 * sizeMultiplier, 2);
                ctx.fillStyle = '#32CD32';
                ctx.fillRect(-halfSize + 6, -halfSize + 2 + bodyOffset, 6 * sizeMultiplier, 2 * sizeMultiplier);
                break;
            case 'berserker':
                // 狂暴僵尸 - 与详细渲染保持一致（更多血迹）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 1 + bodyOffset, 2 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 10, -halfSize + 6 + bodyOffset, 3 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 6, -halfSize + 4 + bodyOffset, 1, 3 * sizeMultiplier);
                break;
        }
    }
    
    drawLevelAura(ctx) {
        const auraRadius = this.radius + 5 + Math.sin(Date.now() / 500) * 3;
        const gradient = ctx.createRadialGradient(0, 0, 0, 0, 0, auraRadius);
        gradient.addColorStop(0, 'rgba(255, 107, 107, 0)');
        gradient.addColorStop(0.7, `rgba(255, 107, 107, ${this.glowIntensity * 0.3})`);
        gradient.addColorStop(1, `rgba(255, 107, 107, ${this.glowIntensity * 0.6})`);
        
        ctx.fillStyle = gradient;
        ctx.beginPath();
        ctx.arc(0, 0, auraRadius, 0, Math.PI * 2);
        ctx.fill();
    }
    
    drawLevelIndicator(ctx) {
        if (this.level <= 1) return;
        
        // 绘制等级数字
        ctx.fillStyle = this.level >= 4 ? '#FFD700' : '#FFFFFF';
        ctx.font = `bold ${8 + this.level}px Arial`;
        ctx.textAlign = 'center';
        ctx.shadowColor = '#000000';
        ctx.shadowBlur = 2;
        ctx.fillText(this.level.toString(), 0, -this.radius - 8);
        ctx.shadowBlur = 0;
        
        // 绘制等级星星
        if (this.level >= 3) {
            const starCount = Math.min(this.level - 2, 3);
            for (let i = 0; i < starCount; i++) {
                const starX = (i - (starCount - 1) / 2) * 8;
                const starY = -this.radius - 20;
                this.drawStar(ctx, starX, starY, 3, '#FFD700');
            }
        }
    }
    
    drawStar(ctx, x, y, size, color) {
        ctx.fillStyle = color;
        ctx.beginPath();
        ctx.moveTo(x, y - size);
        ctx.lineTo(x + size * 0.3, y - size * 0.3);
        ctx.lineTo(x + size, y);
        ctx.lineTo(x + size * 0.3, y + size * 0.3);
        ctx.lineTo(x, y + size);
        ctx.lineTo(x - size * 0.3, y + size * 0.3);
        ctx.lineTo(x - size, y);
        ctx.lineTo(x - size * 0.3, y - size * 0.3);
        ctx.closePath();
        ctx.fill();
    }
    
    drawSkillIndicators(ctx) {
        if (this.level < 2) return;
        
        const indicatorY = this.radius + 15;
        let indicatorIndex = 0;
        
        // 显示技能冷却状态
        if (this.type === 'fast' && this.level >= 3) {
            const progress = 1 - Math.max(0, this.skillCooldowns.charge) / 5000;
            this.drawSkillCooldown(ctx, -10 + indicatorIndex * 8, indicatorY, progress, '#FF4500');
            indicatorIndex++;
        }
        
        if (this.type === 'spitter' && this.level >= 2) {
            const progress = 1 - Math.max(0, this.skillCooldowns.spit) / 3000;
            this.drawSkillCooldown(ctx, -10 + indicatorIndex * 8, indicatorY, progress, '#9ACD32');
            indicatorIndex++;
        }
        
        if (this.type === 'tank' && this.level >= 4) {
            const progress = 1 - Math.max(0, this.skillCooldowns.heal) / 8000;
            this.drawSkillCooldown(ctx, -10 + indicatorIndex * 8, indicatorY, progress, '#32CD32');
            indicatorIndex++;
        }
    }
    
    drawSkillCooldown(ctx, x, y, progress, color) {
        // 技能冷却圆环
        ctx.strokeStyle = progress >= 1 ? color : 'rgba(100, 100, 100, 0.5)';
        ctx.lineWidth = 2;
        ctx.beginPath();
        ctx.arc(x, y, 4, 0, Math.PI * 2);
        ctx.stroke();
        
        if (progress < 1) {
            ctx.strokeStyle = color;
            ctx.beginPath();
            ctx.arc(x, y, 4, -Math.PI/2, -Math.PI/2 + Math.PI * 2 * progress);
            ctx.stroke();
        } else {
            // 技能可用时发光
            ctx.fillStyle = color;
            ctx.beginPath();
            ctx.arc(x, y, 2, 0, Math.PI * 2);
            ctx.fill();
        }
    }
    
    drawZombie_OLD_REMOVED(ctx) {
        // 旧的drawZombie方法已删除 - 只处理原有僵尸类型，导致新僵尸显示为普通僵尸
        // 请使用 drawZombieCorrect 方法
        console.error('调用了已删除的旧drawZombie方法，请使用drawZombieCorrect');
        return;
        const size = 18; // 稍微增大尺寸
        const halfSize = size / 2;
        
        // 移动动画
        let bodyOffset = 0;
        let legOffset = 0;
        if (this.state === 'chasing' || this.state === 'wandering') {
            bodyOffset = Math.sin(this.animationFrame * Math.PI / 4) * 1.5;
            legOffset = Math.sin(this.animationFrame * Math.PI / 2) * 2;
        }
        
        // 阴影
        ctx.fillStyle = 'rgba(0, 0, 0, 0.4)';
        ctx.fillRect(-halfSize + 2, halfSize + 2, size - 4, 3);
        
        // 腿部 (带蹒跚动画)
        ctx.fillStyle = this.colors.clothes;
        ctx.fillRect(-halfSize + 2, halfSize - 8, 5, 8 + legOffset);
        ctx.fillRect(-halfSize + 11, halfSize - 8, 5, 8 - legOffset);
        
        // 破烂的鞋子
        ctx.fillStyle = '#2F2F2F';
        ctx.fillRect(-halfSize + 1, halfSize - 2, 6, 3);
        ctx.fillRect(-halfSize + 11, halfSize - 2, 6, 3);
        
        // 身体躯干
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-halfSize + 1, -halfSize + 4 + bodyOffset, size - 2, 12);
        
        // 破烂的衣服
        ctx.fillStyle = this.colors.clothes;
        ctx.fillRect(-halfSize + 2, -halfSize + 5 + bodyOffset, size - 4, 8);
        
        // 衣服撕裂效果
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-halfSize + 3, -halfSize + 6 + bodyOffset, 2, 3);
        ctx.fillRect(-halfSize + 12, -halfSize + 8 + bodyOffset, 3, 2);
        
        // 僵尸手臂 - 不同姿势
        ctx.fillStyle = this.colors.body;
        if (this.state === 'attacking') {
            // 攻击姿势 - 手臂前伸
            ctx.fillRect(-halfSize - 3, -halfSize + 2 + bodyOffset, 5, 6);
            ctx.fillRect(halfSize - 2, -halfSize + 2 + bodyOffset, 5, 6);
        } else {
            // 普通姿势 - 手臂下垂
            ctx.fillRect(-halfSize - 1, -halfSize + 4 + bodyOffset, 3, 8);
            ctx.fillRect(halfSize - 2, -halfSize + 4 + bodyOffset, 3, 8);
        }
        
        // 头部
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-halfSize + 3, -halfSize + bodyOffset, 12, 8);
        
        // 腐烂的头发
        ctx.fillStyle = this.darkenColor(this.colors.body, 0.5);
        ctx.fillRect(-halfSize + 2, -halfSize - 1 + bodyOffset, 14, 3);
        // 缺失的头发块
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-halfSize + 6, -halfSize - 1 + bodyOffset, 3, 2);
        
        // 恐怖的面部特征
        ctx.fillStyle = this.colors.eyes;
        // 血红眼睛
        ctx.fillRect(-halfSize + 5, -halfSize + 2 + bodyOffset, 2, 2);
        ctx.fillRect(-halfSize + 11, -halfSize + 2 + bodyOffset, 2, 2);
        
        // 张开的嘴巴
        ctx.fillStyle = '#1A1A1A';
        ctx.fillRect(-halfSize + 7, -halfSize + 5 + bodyOffset, 4, 2);
        
        // 露出的牙齿
        ctx.fillStyle = '#FFFACD';
        ctx.fillRect(-halfSize + 7, -halfSize + 5 + bodyOffset, 1, 1);
        ctx.fillRect(-halfSize + 9, -halfSize + 5 + bodyOffset, 1, 1);
        
        // 血迹和伤口
        ctx.fillStyle = this.colors.blood;
        ctx.fillRect(-halfSize + 4, -halfSize + 1 + bodyOffset, 2, 1);
        ctx.fillRect(-halfSize + 10, -halfSize + 6 + bodyOffset, 3, 1);
        ctx.fillRect(-halfSize + 2, -halfSize + 10 + bodyOffset, 2, 2);
        ctx.fillRect(-halfSize + 13, -halfSize + 8 + bodyOffset, 2, 2);
        
        // 类型特殊标识 - 旧方法已禁用
        // this.drawTypeSpecificFeatures(ctx, size, bodyOffset);
    }
    
    drawTypeSpecificFeatures_OLD_REMOVED(ctx, size, bodyOffset) {
        // 旧的drawTypeSpecificFeatures方法已删除 - 只处理原有僵尸类型
        // 请使用 drawNewZombieSpecialFeatures 方法
        console.error('调用了已删除的旧drawTypeSpecificFeatures方法');
        return;
        const halfSize = size / 2;
        
        switch (this.type) {
            case 'fast':
                // 瘦长身形 - 更加消瘦
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.3);
                ctx.fillRect(-halfSize + 1, -halfSize + 2 + bodyOffset, size - 2, 2); // 更细的身体
                
                // 长爪子
                ctx.fillStyle = '#2F2F2F';
                ctx.fillRect(-halfSize - 2, -halfSize + 6 + bodyOffset, 2, 4);
                ctx.fillRect(halfSize, -halfSize + 6 + bodyOffset, 2, 4);
                
                // 突出的肋骨
                ctx.fillStyle = '#FFFACD';
                ctx.fillRect(-halfSize + 3, -halfSize + 8 + bodyOffset, 1, 2);
                ctx.fillRect(-halfSize + 5, -halfSize + 9 + bodyOffset, 1, 2);
                break;
                
            case 'tank':
                // 更大更强壮的体型
                ctx.fillStyle = this.colors.body;
                // 额外的肌肉块
                ctx.fillRect(-halfSize - 3, -halfSize + 2 + bodyOffset, 3, 8);
                ctx.fillRect(halfSize, -halfSize + 2 + bodyOffset, 3, 8);
                
                // 厚重的肩膀
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.2);
                ctx.fillRect(-halfSize + 1, -halfSize + 1 + bodyOffset, size - 2, 4);
                
                // 疤痕
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 3 + bodyOffset, 8, 1);
                ctx.fillRect(-halfSize + 6, -halfSize + 9 + bodyOffset, 6, 1);
                break;
                
            case 'spitter':
                // 绿色毒液从嘴里滴出
                ctx.fillStyle = '#00FF00';
                ctx.fillRect(-halfSize + 8, -halfSize + 7 + bodyOffset, 2, 3);
                ctx.fillRect(-halfSize + 7, -halfSize + 10 + bodyOffset, 1, 2);
                
                // 腐蚀性伤口
                ctx.fillStyle = '#32CD32';
                ctx.fillRect(-halfSize + 3, -halfSize + 4 + bodyOffset, 2, 2);
                ctx.fillRect(-halfSize + 11, -halfSize + 7 + bodyOffset, 2, 2);
                
                // 毒液囊 (在脖子处)
                ctx.fillStyle = '#228B22';
                ctx.fillRect(-halfSize + 6, -halfSize + 2 + bodyOffset, 6, 3);
                break;
        }
    }
    
    drawHealthBar(ctx) {
        const barWidth = 20;
        const barHeight = 3;
        const healthPercent = this.health / this.maxHealth;
        
        // 背景
        ctx.fillStyle = '#333333';
        ctx.fillRect(-barWidth/2, -25, barWidth, barHeight);
        
        // 血量
        ctx.fillStyle = healthPercent > 0.5 ? '#00FF00' : healthPercent > 0.25 ? '#FFFF00' : '#FF0000';
        ctx.fillRect(-barWidth/2, -25, barWidth * healthPercent, barHeight);
    }
    
    drawZombieCorrect(ctx) {
        // 应用透明度（隐身效果）
        if (this.alpha !== undefined) {
            ctx.globalAlpha = this.alpha;
        }
        
        // 所有僵尸都使用相同的基础绘制方法，确保一致性
        this.drawUnifiedZombie(ctx);
        
        // 恢复透明度
        if (this.alpha !== undefined) {
            ctx.globalAlpha = 1;
        }
    }
    
    // === 统一僵尸绘制方法（所有僵尸都使用相同基础） ===
    drawUnifiedZombie(ctx) {
        // 根据类型调整体型（仅限巨型和隐身）
        let sizeMultiplier = 1;
        if (this.type === 'giant') sizeMultiplier = 1.4;
        if (this.type === 'stealth') sizeMultiplier = 0.9;
        
        this.drawZombieBase(ctx, sizeMultiplier);
    }
    
    drawZombieBase(ctx, sizeMultiplier = 1) {
        const size = 18 * sizeMultiplier;
        const halfSize = size / 2;
        
        // 移动动画
        let bodyOffset = 0;
        let legOffset = 0;
        if (this.state === 'chasing' || this.state === 'wandering') {
            bodyOffset = Math.sin(this.animationFrame * Math.PI / 4) * 1.5;
            legOffset = Math.sin(this.animationFrame * Math.PI / 2) * 2;
        }
        
        // 阴影
        ctx.fillStyle = 'rgba(0, 0, 0, 0.4)';
        ctx.fillRect(-halfSize + 2, halfSize + 2, size - 4, 3);
        
        // 腿部 (带蹒跚动画)
        ctx.fillStyle = this.colors.clothes;
        ctx.fillRect(-halfSize + 2, halfSize - 8, 5, 8 + legOffset);
        ctx.fillRect(-halfSize + 11, halfSize - 8, 5, 8 - legOffset);
        
        // 破烂的鞋子
        ctx.fillStyle = '#2F2F2F';
        ctx.fillRect(-halfSize + 1, halfSize - 2, 6, 3);
        ctx.fillRect(-halfSize + 11, halfSize - 2, 6, 3);
        
        // 身体躯干
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-halfSize + 1, -halfSize + 4 + bodyOffset, size - 2, 12);
        
        // 破烂的衣服
        ctx.fillStyle = this.colors.clothes;
        ctx.fillRect(-halfSize + 2, -halfSize + 5 + bodyOffset, size - 4, 8);
        
        // 衣服撕裂效果
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-halfSize + 3, -halfSize + 6 + bodyOffset, 2, 3);
        ctx.fillRect(-halfSize + 12, -halfSize + 8 + bodyOffset, 3, 2);
        
        // 僵尸手臂 - 不同姿势
        ctx.fillStyle = this.colors.body;
        if (this.state === 'attacking') {
            // 攻击姿势 - 手臂前伸
            ctx.fillRect(-halfSize - 3, -halfSize + 2 + bodyOffset, 5, 6);
            ctx.fillRect(halfSize - 2, -halfSize + 2 + bodyOffset, 5, 6);
        } else {
            // 普通姿势 - 手臂下垂
            ctx.fillRect(-halfSize - 1, -halfSize + 4 + bodyOffset, 3, 8);
            ctx.fillRect(halfSize - 2, -halfSize + 4 + bodyOffset, 3, 8);
        }
        
        // 头部
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-halfSize + 3, -halfSize + bodyOffset, 12, 8);
        
        // 腐烂的头发
        ctx.fillStyle = this.darkenColor(this.colors.body, 0.5);
        ctx.fillRect(-halfSize + 2, -halfSize - 1 + bodyOffset, 14, 3);
        // 缺失的头发块
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-halfSize + 6, -halfSize - 1 + bodyOffset, 3, 2);
        
        // 恐怖的面部特征
        ctx.fillStyle = this.colors.eyes;
        // 血红眼睛
        ctx.fillRect(-halfSize + 5, -halfSize + 2 + bodyOffset, 2, 2);
        ctx.fillRect(-halfSize + 11, -halfSize + 2 + bodyOffset, 2, 2);
        
        // 张开的嘴巴
        ctx.fillStyle = '#1A1A1A';
        ctx.fillRect(-halfSize + 7, -halfSize + 5 + bodyOffset, 4, 2);
        
        // 露出的牙齿
        ctx.fillStyle = '#FFFACD';
        ctx.fillRect(-halfSize + 7, -halfSize + 5 + bodyOffset, 1, 1);
        ctx.fillRect(-halfSize + 9, -halfSize + 5 + bodyOffset, 1, 1);
        
        // 血迹和伤口
        ctx.fillStyle = this.colors.blood;
        ctx.fillRect(-halfSize + 4, -halfSize + 1 + bodyOffset, 2, 1);
        ctx.fillRect(-halfSize + 10, -halfSize + 6 + bodyOffset, 3, 1);
        ctx.fillRect(-halfSize + 2, -halfSize + 10 + bodyOffset, 2, 2);
        ctx.fillRect(-halfSize + 13, -halfSize + 8 + bodyOffset, 2, 2);
        
        // 类型特殊标识（所有僵尸类型）
        this.drawUnifiedTypeSpecificFeatures(ctx, size, bodyOffset, sizeMultiplier);
    }
    
    drawUnifiedTypeSpecificFeatures(ctx, size, bodyOffset, sizeMultiplier = 1) {
        const halfSize = size / 2;
        
        switch (this.type) {
            case 'fast':
                // 瘦长身形 - 更加消瘦
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.3);
                ctx.fillRect(-halfSize + 1, -halfSize + 2 + bodyOffset, size - 2, 2); // 更细的身体
                
                // 长爪子
                ctx.fillStyle = '#2F2F2F';
                ctx.fillRect(-halfSize - 2, -halfSize + 6 + bodyOffset, 2, 4);
                ctx.fillRect(halfSize, -halfSize + 6 + bodyOffset, 2, 4);
                
                // 突出的肋骨
                ctx.fillStyle = '#FFFACD';
                ctx.fillRect(-halfSize + 3, -halfSize + 8 + bodyOffset, 1, 2);
                ctx.fillRect(-halfSize + 5, -halfSize + 9 + bodyOffset, 1, 2);
                break;
                
            case 'tank':
                // 更大更强壮的体型
                ctx.fillStyle = this.colors.body;
                // 额外的肌肉块
                ctx.fillRect(-halfSize - 3, -halfSize + 2 + bodyOffset, 3, 8);
                ctx.fillRect(halfSize, -halfSize + 2 + bodyOffset, 3, 8);
                
                // 厚重的肩膀
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.2);
                ctx.fillRect(-halfSize + 1, -halfSize + 1 + bodyOffset, size - 2, 4);
                
                // 疤痕
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 3 + bodyOffset, 8, 1);
                ctx.fillRect(-halfSize + 6, -halfSize + 9 + bodyOffset, 6, 1);
                break;
                
            case 'spitter':
                // 绿色毒液从嘴里滴出
                ctx.fillStyle = '#00FF00';
                ctx.fillRect(-halfSize + 8, -halfSize + 7 + bodyOffset, 2, 3);
                ctx.fillRect(-halfSize + 7, -halfSize + 10 + bodyOffset, 1, 2);
                
                // 腐蚀性伤口
                ctx.fillStyle = '#32CD32';
                ctx.fillRect(-halfSize + 3, -halfSize + 4 + bodyOffset, 2, 2);
                ctx.fillRect(-halfSize + 11, -halfSize + 7 + bodyOffset, 2, 2);
                
                // 毒液囊 (在脖子处)
                ctx.fillStyle = '#228B22';
                ctx.fillRect(-halfSize + 6, -halfSize + 2 + bodyOffset, 6, 3);
                break;
                
            // === 新僵尸类型（完全基于原有设计风格） ===
            case 'exploder':
                // 爆炸僵尸 - 基于tank的设计，增加更多疤痕
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 3 + bodyOffset, 8, 1); // tank的疤痕
                ctx.fillRect(-halfSize + 6, -halfSize + 9 + bodyOffset, 6, 1);
                // 额外的血迹
                ctx.fillRect(-halfSize + 2, -halfSize + 5 + bodyOffset, 2, 2);
                ctx.fillRect(-halfSize + 13, -halfSize + 7 + bodyOffset, 2, 2);
                break;
                
            case 'electric':
                // 电击僵尸 - 基于spitter的设计，但使用深色标记
                ctx.fillStyle = this.darkenColor(this.colors.clothes, 0.4);
                ctx.fillRect(-halfSize + 8, -halfSize + 7 + bodyOffset, 2, 3); // spitter的液体位置
                ctx.fillRect(-halfSize + 7, -halfSize + 10 + bodyOffset, 1, 2);
                
                // 电路纹路（类似spitter的毒液囊）
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.3);
                ctx.fillRect(-halfSize + 6, -halfSize + 2 + bodyOffset, 6, 3);
                break;
                
            case 'stealth':
                // 隐身僵尸 - 基于fast的设计，但眼睛颜色深一些
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.3);
                ctx.fillRect(-halfSize + 1, -halfSize + 2 + bodyOffset, size - 2, 2); // fast的瘦身体
                
                // 特殊眼睛颜色
                ctx.fillStyle = this.darkenColor(this.colors.eyes, 0.3);
                ctx.fillRect(-halfSize + 5, -halfSize + 2 + bodyOffset, 2, 2);
                ctx.fillRect(-halfSize + 11, -halfSize + 2 + bodyOffset, 2, 2);
                break;
                
            case 'giant':
                // 巨型僵尸 - 基于tank的设计，增强版
                ctx.fillStyle = this.colors.body;
                ctx.fillRect(-halfSize - 3, -halfSize + 2 + bodyOffset, 3, 8); // tank的肌肉块
                ctx.fillRect(halfSize, -halfSize + 2 + bodyOffset, 3, 8);
                
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.2);
                ctx.fillRect(-halfSize + 1, -halfSize + 1 + bodyOffset, size - 2, 4); // tank的肩膀
                
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 3 + bodyOffset, 8, 1); // tank的疤痕
                ctx.fillRect(-halfSize + 6, -halfSize + 9 + bodyOffset, 6, 1);
                break;
                
            case 'splitter':
                // 分裂僵尸 - 基于fast的设计，增加血迹裂缝
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.3);
                ctx.fillRect(-halfSize + 1, -halfSize + 2 + bodyOffset, size - 2, 2); // fast的瘦身体
                
                // 血迹裂缝
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 1 + bodyOffset, 2, 1);
                ctx.fillRect(-halfSize + 10, -halfSize + 6 + bodyOffset, 3, 1);
                break;
                
            case 'healer':
                // 治愈僵尸 - 基于spitter的设计，但使用绿色
                ctx.fillStyle = '#228B22'; // spitter的绿色
                ctx.fillRect(-halfSize + 8, -halfSize + 7 + bodyOffset, 2, 3); // spitter的液体位置
                ctx.fillRect(-halfSize + 7, -halfSize + 10 + bodyOffset, 1, 2);
                
                // 治愈标记（类似spitter的毒液囊）
                ctx.fillStyle = '#32CD32';
                ctx.fillRect(-halfSize + 6, -halfSize + 2 + bodyOffset, 6, 3);
                break;
                
            case 'berserker':
                // 狂暴僵尸 - 基于tank的设计，更多血迹
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 3 + bodyOffset, 8, 1); // tank的疤痕
                ctx.fillRect(-halfSize + 6, -halfSize + 9 + bodyOffset, 6, 1);
                
                // 额外的血迹（更多位置）
                ctx.fillRect(-halfSize + 2, -halfSize + 1 + bodyOffset, 2, 1);
                ctx.fillRect(-halfSize + 10, -halfSize + 5 + bodyOffset, 3, 1);
                ctx.fillRect(-halfSize + 6, -halfSize + 7 + bodyOffset, 1, 3);
                break;
        }
    }
    
    // === 旧的复杂新僵尸绘制方法（已删除） ===
    drawNewZombieType_OLD_REMOVED(ctx) {
        console.error('调用了已删除的复杂绘制方法，请使用drawUnifiedZombie');
        return;
        // 以下代码已被禁用
        // 基于原始僵尸绘制，保持僵尸本质
        const size = this.stats && this.stats.size ? this.stats.size : 18;
        const halfSize = size / 2;
        
        // 移动动画（与原版一致）
        let bodyOffset = 0;
        let legOffset = 0;
        if (this.state === 'chasing' || this.state === 'wandering') {
            bodyOffset = Math.sin(this.animationFrame * Math.PI / 4) * 1.5;
            legOffset = Math.sin(this.animationFrame * Math.PI / 2) * 2;
        }
        
        // 根据类型调整体型
        let sizeMultiplier = 1;
        if (this.type === 'giant') sizeMultiplier = 1.8;
        if (this.type === 'stealth') sizeMultiplier = 0.9;
        
        const actualSize = size * sizeMultiplier;
        const actualHalfSize = actualSize / 2;
        
        // 阴影
        ctx.fillStyle = 'rgba(0, 0, 0, 0.4)';
        ctx.fillRect(-actualHalfSize + 2, actualHalfSize + 2, actualSize - 4, 3);
        
        // 腿部 (带蹒跚动画)
        ctx.fillStyle = this.colors.clothes;
        ctx.fillRect(-actualHalfSize + 2, actualHalfSize - 8, 5 * sizeMultiplier, 8 + legOffset);
        ctx.fillRect(-actualHalfSize + 11 * sizeMultiplier, actualHalfSize - 8, 5 * sizeMultiplier, 8 - legOffset);
        
        // 破烂的鞋子
        ctx.fillStyle = '#2F2F2F';
        ctx.fillRect(-actualHalfSize + 1, actualHalfSize - 2, 6 * sizeMultiplier, 3);
        ctx.fillRect(-actualHalfSize + 11 * sizeMultiplier, actualHalfSize - 2, 6 * sizeMultiplier, 3);
        
        // 身体躯干
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-actualHalfSize + 1, -actualHalfSize + 4 + bodyOffset, actualSize - 2, 12 * sizeMultiplier);
        
        // 破烂的衣服
        ctx.fillStyle = this.colors.clothes;
        ctx.fillRect(-actualHalfSize + 2, -actualHalfSize + 5 + bodyOffset, actualSize - 4, 8 * sizeMultiplier);
        
        // 衣服撕裂效果
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-actualHalfSize + 3, -actualHalfSize + 6 + bodyOffset, 2 * sizeMultiplier, 3 * sizeMultiplier);
        ctx.fillRect(-actualHalfSize + 12 * sizeMultiplier, -actualHalfSize + 8 + bodyOffset, 3 * sizeMultiplier, 2 * sizeMultiplier);
        
        // 僵尸手臂 - 不同姿势
        ctx.fillStyle = this.colors.body;
        if (this.state === 'attacking') {
            // 攻击姿势 - 手臂前伸
            ctx.fillRect(-actualHalfSize - 3, -actualHalfSize + 2 + bodyOffset, 5 * sizeMultiplier, 6 * sizeMultiplier);
            ctx.fillRect(actualHalfSize - 2, -actualHalfSize + 2 + bodyOffset, 5 * sizeMultiplier, 6 * sizeMultiplier);
        } else {
            // 普通姿势 - 手臂下垂
            ctx.fillRect(-actualHalfSize - 1, -actualHalfSize + 4 + bodyOffset, 3 * sizeMultiplier, 8 * sizeMultiplier);
            ctx.fillRect(actualHalfSize - 2, -actualHalfSize + 4 + bodyOffset, 3 * sizeMultiplier, 8 * sizeMultiplier);
        }
        
        // 头部
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-actualHalfSize + 3, -actualHalfSize + bodyOffset, 12 * sizeMultiplier, 8 * sizeMultiplier);
        
        // 腐烂的头发
        ctx.fillStyle = this.darkenColor(this.colors.body, 0.5);
        ctx.fillRect(-actualHalfSize + 2, -actualHalfSize - 1 + bodyOffset, 14 * sizeMultiplier, 3 * sizeMultiplier);
        // 缺失的头发块
        ctx.fillStyle = this.colors.body;
        ctx.fillRect(-actualHalfSize + 6, -actualHalfSize - 1 + bodyOffset, 3 * sizeMultiplier, 2 * sizeMultiplier);
        
        // 恐怖的面部特征
        ctx.fillStyle = this.colors.eyes;
        // 血红眼睛
        ctx.fillRect(-actualHalfSize + 5, -actualHalfSize + 2 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
        ctx.fillRect(-actualHalfSize + 11 * sizeMultiplier, -actualHalfSize + 2 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
        
        // 张开的嘴巴
        ctx.fillStyle = '#1A1A1A';
        ctx.fillRect(-actualHalfSize + 7, -actualHalfSize + 5 + bodyOffset, 4 * sizeMultiplier, 2 * sizeMultiplier);
        
        // 露出的牙齿
        ctx.fillStyle = '#FFFACD';
        ctx.fillRect(-actualHalfSize + 7, -actualHalfSize + 5 + bodyOffset, 1 * sizeMultiplier, 1 * sizeMultiplier);
        ctx.fillRect(-actualHalfSize + 9, -actualHalfSize + 5 + bodyOffset, 1 * sizeMultiplier, 1 * sizeMultiplier);
        
        // 血迹和伤口
        ctx.fillStyle = this.colors.blood;
        ctx.fillRect(-actualHalfSize + 4, -actualHalfSize + 1 + bodyOffset, 2 * sizeMultiplier, 1 * sizeMultiplier);
        ctx.fillRect(-actualHalfSize + 10, -actualHalfSize + 6 + bodyOffset, 3 * sizeMultiplier, 1 * sizeMultiplier);
        ctx.fillRect(-actualHalfSize + 2, -actualHalfSize + 10 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
        ctx.fillRect(-actualHalfSize + 13 * sizeMultiplier, -actualHalfSize + 8 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
        
        // 新僵尸类型的特殊标识 - 已删除，使用统一方法
        // this.drawNewZombieSpecialFeatures(ctx, actualSize, actualHalfSize, bodyOffset, sizeMultiplier);
    }
    
    drawNewZombieSpecialFeatures_OLD_REMOVED(ctx, size, halfSize, bodyOffset, sizeMultiplier) {
        console.error('调用了已删除的新僵尸特征方法，请使用drawUnifiedTypeSpecificFeatures');
        return;
        // 以下代码已被禁用
        switch (this.type) {
            case 'exploder':
                // 爆炸僵尸 - 完全遵循原有风格，类似tank的设计
                // 胸前危险标记（类似tank的疤痕）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 3 + bodyOffset, 8 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 6, -halfSize + 9 + bodyOffset, 6 * sizeMultiplier, 1);
                
                // 额外的血迹（类似原有的血迹但更多）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 2, -halfSize + 5 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                ctx.fillRect(-halfSize + 12 * sizeMultiplier, -halfSize + 7 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                break;
                
            case 'electric':
                // 电击僵尸 - 完全遵循原有风格，类似spitter的设计
                // 蓝色"毒液"从身体流出（类似spitter但颜色不同）
                ctx.fillStyle = this.darkenColor(this.colors.clothes, 0.4); // 使用深色衣服颜色
                ctx.fillRect(-halfSize + 8, -halfSize + 7 + bodyOffset, 2 * sizeMultiplier, 3 * sizeMultiplier);
                ctx.fillRect(-halfSize + 7, -halfSize + 10 + bodyOffset, 1, 2 * sizeMultiplier);
                
                // 电路纹路（类似spitter的毒液囊）
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.3);
                ctx.fillRect(-halfSize + 6, -halfSize + 2 + bodyOffset, 6 * sizeMultiplier, 3 * sizeMultiplier);
                
                // 特殊标记（类似血迹）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 3, -halfSize + 4 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                ctx.fillRect(-halfSize + 11 * sizeMultiplier, -halfSize + 7 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                break;
                
            case 'stealth':
                // 隐身僵尸 - 完全遵循原有风格，类似fast的设计
                // 特殊眼睛颜色（但保持红色）
                ctx.fillStyle = this.darkenColor(this.colors.eyes, 0.3);
                ctx.fillRect(-halfSize + 5, -halfSize + 2 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                ctx.fillRect(-halfSize + 11 * sizeMultiplier, -halfSize + 2 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                
                // 神秘标记（类似血迹但颜色不同）
                ctx.fillStyle = this.darkenColor(this.colors.clothes, 0.5);
                ctx.fillRect(-halfSize + 7, -halfSize + 8 + bodyOffset, 4 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 8, -halfSize + 10 + bodyOffset, 2 * sizeMultiplier, 1);
                break;
                
            case 'giant':
                // 巨型僵尸 - 完全遵循原有风格，增强tank的设计
                // 额外的肌肉块（类似tank但更大）
                ctx.fillStyle = this.colors.body;
                ctx.fillRect(-halfSize - 3, -halfSize + 2 + bodyOffset, 3, 8);
                ctx.fillRect(halfSize, -halfSize + 2 + bodyOffset, 3, 8);
                
                // 更厚重的肩膀
                ctx.fillStyle = this.darkenColor(this.colors.body, 0.2);
                ctx.fillRect(-halfSize + 1, -halfSize + 1 + bodyOffset, size - 2, 4);
                
                // 更多疤痕（血色）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 3, -halfSize + 2 + bodyOffset, size - 6, 1);
                ctx.fillRect(-halfSize + 5, -halfSize + 8 + bodyOffset, size - 10, 1);
                break;
                
            case 'splitter':
                // 分裂僵尸 - 完全遵循原有风格，类似fast的设计
                // 身体裂缝（类似原有的血迹）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 1 + bodyOffset, 2 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 10, -halfSize + 6 + bodyOffset, 3 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 2, -halfSize + 10 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                
                // 突出的肌肉（类似fast的肌肉设计）
                ctx.fillStyle = this.colors.body;
                ctx.fillRect(-halfSize + 3, -halfSize + 8 + bodyOffset, 1, 2 * sizeMultiplier);
                ctx.fillRect(-halfSize + 14 * sizeMultiplier, -halfSize + 9 + bodyOffset, 1, 2 * sizeMultiplier);
                break;
                
            case 'healer':
                // 治愈僵尸 - 完全遵循原有风格，类似spitter的设计
                // 绿色标记（类似spitter的绿色毒液）
                ctx.fillStyle = '#228B22'; // 使用与spitter相同的绿色
                ctx.fillRect(-halfSize + 8, -halfSize + 7 + bodyOffset, 2 * sizeMultiplier, 3 * sizeMultiplier);
                ctx.fillRect(-halfSize + 7, -halfSize + 10 + bodyOffset, 1, 2 * sizeMultiplier);
                
                // 治愈标记（类似spitter的毒液囊）
                ctx.fillStyle = '#32CD32'; // 使用与spitter相同的绿色系列
                ctx.fillRect(-halfSize + 6, -halfSize + 2 + bodyOffset, 6 * sizeMultiplier, 3 * sizeMultiplier);
                
                // 特殊标记（类似血迹）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 3, -halfSize + 4 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                break;
                
            case 'berserker':
                // 狂暴僵尸 - 完全遵循原有风格，类似tank的设计
                // 额外的血迹（类似原有的血迹但更多）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 4, -halfSize + 1 + bodyOffset, 2 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 10, -halfSize + 6 + bodyOffset, 3 * sizeMultiplier, 1);
                ctx.fillRect(-halfSize + 2, -halfSize + 10 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                ctx.fillRect(-halfSize + 13 * sizeMultiplier, -halfSize + 8 + bodyOffset, 2 * sizeMultiplier, 2 * sizeMultiplier);
                
                // 额外的血迹（更多位置）
                ctx.fillStyle = this.colors.blood;
                ctx.fillRect(-halfSize + 6, -halfSize + 4 + bodyOffset, 1, 3 * sizeMultiplier);
                ctx.fillRect(-halfSize + 11 * sizeMultiplier, -halfSize + 5 + bodyOffset, 1, 4 * sizeMultiplier);
                break;
        }
    }
    
    drawHealthBar(ctx) {
        const barWidth = this.radius * 1.5;
        const barHeight = 4;
        const healthPercent = this.health / this.maxHealth;
        
        // 背景
        ctx.fillStyle = '#333333';
        ctx.fillRect(-barWidth/2, -this.radius - 15, barWidth, barHeight);
        
        // 血量条
        let healthColor;
        if (healthPercent > 0.6) {
            healthColor = '#00FF00';
        } else if (healthPercent > 0.3) {
            healthColor = '#FFFF00';
        } else {
            healthColor = '#FF0000';
        }
        
        ctx.fillStyle = healthColor;
        ctx.fillRect(-barWidth/2, -this.radius - 15, barWidth * healthPercent, barHeight);
        
        // 边框
        ctx.strokeStyle = '#FFFFFF';
        ctx.lineWidth = 1;
        ctx.strokeRect(-barWidth/2, -this.radius - 15, barWidth, barHeight);
    }
    
    drawAggroIndicator(ctx) {
        // 愤怒指示器
        ctx.fillStyle = '#FF0000';
        ctx.font = '12px monospace';
        ctx.textAlign = 'center';
        ctx.fillText('!', 0, -30);
    }
}

// 僵尸生成器 - 也需要修复
class ZombieSpawner {
    constructor() {
        this.spawnPoints = [];
        this.zombieTypes = ['normal', 'fast', 'tank', 'spitter'];
        this.spawnedThisWave = 0;
        this.maxZombiesPerWave = 5;
        this.waveNumber = 1;
    }
    
    addSpawnPoint(x, y) {
        this.spawnPoints.push({ x, y });
    }
    
    spawnWave(level) {
        window.debugLog && window.debugLog(`ZombieSpawner.spawnWave(${level}) 开始`);
        
        try {
            const zombiesToSpawn = Math.min(5 + level * 2, 20);
            const zombies = [];
            window.debugLog && window.debugLog(`需要生成${zombiesToSpawn}只僵尸`);
            
            for (let i = 0; i < zombiesToSpawn; i++) {
                try {
                    const spawnPoint = this.getRandomSpawnPoint();
                    const zombieType = this.getZombieTypeForLevel(level);
                    
                    if (!spawnPoint) {
                        throw new Error('获取生成点失败');
                    }
                    
                    const zombieLevel = this.getZombieLevelForLevel(level);
                    const zombie = new Zombie(spawnPoint.x, spawnPoint.y, zombieType, zombieLevel);
                    zombies.push(zombie);
                } catch (zombieError) {
                    console.error(`创建第${i}只僵尸失败:`, zombieError);
                    window.debugLog && window.debugLog(`创建第${i}只僵尸失败: ${zombieError.message}`);
                    // 继续创建其他僵尸，不要因为一只僵尸失败就全部失败
                }
            }
            
            window.debugLog && window.debugLog(`✓ 成功生成${zombies.length}只僵尸`);
            return zombies;
        } catch (error) {
            console.error('ZombieSpawner.spawnWave 失败:', error);
            window.debugLog && window.debugLog(`✗ ZombieSpawner.spawnWave 失败: ${error.message}`);
            // 返回空数组而不是抛出错误，让游戏可以继续
            return [];
        }
    }
    
    getRandomSpawnPoint() {
        const canvas = document.getElementById('gameCanvas');
        
        // 安全检查canvas是否存在
        if (!canvas) {
            console.error('找不到gameCanvas元素，使用默认生成点');
            return { x: 500, y: 375 }; // 使用默认中心点
        }
        
        if (this.spawnPoints.length === 0) {
            // 在屏幕内边缘生成，确保可见
            const side = Math.floor(Math.random() * 4);
            const margin = 50; // 距离边缘的距离
            
            try {
                switch (side) {
                    case 0: return { x: Math.random() * (canvas.width - 2 * margin) + margin, y: margin }; // 上
                    case 1: return { x: canvas.width - margin, y: Math.random() * (canvas.height - 2 * margin) + margin }; // 右
                    case 2: return { x: Math.random() * (canvas.width - 2 * margin) + margin, y: canvas.height - margin }; // 下
                    case 3: return { x: margin, y: Math.random() * (canvas.height - 2 * margin) + margin }; // 左
                    default: return { x: canvas.width / 2, y: canvas.height / 2 };
                }
            } catch (error) {
                console.error('生成随机生成点失败:', error);
                return { x: 500, y: 375 }; // 使用默认中心点
            }
        }
        
        return this.spawnPoints[Math.floor(Math.random() * this.spawnPoints.length)];
    }
    
    getZombieTypeForLevel(level) {
        // 1-10关：原有僵尸类型
        if (level <= 2) return 'normal';
        if (level <= 4) return Math.random() < 0.7 ? 'normal' : 'fast';
        if (level <= 6) {
            const rand = Math.random();
            if (rand < 0.5) return 'normal';
            if (rand < 0.8) return 'fast';
            return 'tank';
        }
        if (level <= 8) {
            const rand = Math.random();
            if (rand < 0.3) return 'normal';
            if (rand < 0.6) return 'fast';
            if (rand < 0.85) return 'tank';
            return 'spitter';
        }
        if (level <= 10) {
            // 第9-10关：原有类型混合
            const types = ['normal', 'fast', 'tank', 'spitter'];
            return types[Math.floor(Math.random() * types.length)];
        }
        
        // === 11-20关：引入新僵尸类型 ===
        if (level === 11) {
            // 第11关：引入爆炸僵尸
            const types = ['fast', 'tank', 'spitter', 'exploder'];
            return types[Math.floor(Math.random() * types.length)];
        }
        if (level === 12) {
            // 第12关：引入电击僵尸
            const types = ['tank', 'spitter', 'exploder', 'electric'];
            return types[Math.floor(Math.random() * types.length)];
        }
        if (level === 13) {
            // 第13关：引入隐身僵尸
            const types = ['spitter', 'exploder', 'electric', 'stealth'];
            return types[Math.floor(Math.random() * types.length)];
        }
        if (level === 14) {
            // 第14关：引入巨型僵尸
            const types = ['exploder', 'electric', 'stealth', 'giant'];
            return types[Math.floor(Math.random() * types.length)];
        }
        if (level === 15) {
            // 第15关：引入分裂僵尸
            const types = ['electric', 'stealth', 'giant', 'splitter'];
            return types[Math.floor(Math.random() * types.length)];
        }
        if (level === 16) {
            // 第16关：引入治愈僵尸
            const types = ['stealth', 'giant', 'splitter', 'healer'];
            return types[Math.floor(Math.random() * types.length)];
        }
        if (level === 17) {
            // 第17关：引入狂暴僵尸
            const types = ['giant', 'splitter', 'healer', 'berserker'];
            return types[Math.floor(Math.random() * types.length)];
        }
        if (level === 18) {
            // 第18关：所有新类型混合
            const types = ['exploder', 'electric', 'stealth', 'giant', 'splitter', 'healer', 'berserker'];
            return types[Math.floor(Math.random() * types.length)];
        }
        if (level === 19) {
            // 第19关：最强僵尸组合
            const types = ['giant', 'splitter', 'healer', 'berserker'];
            return types[Math.floor(Math.random() * types.length)];
        }
        if (level === 20) {
            // 第20关：终极战，精英僵尸守护
            const types = ['giant', 'berserker', 'healer'];
            return types[Math.floor(Math.random() * types.length)];
        }
        
        // 默认：所有类型随机
        const allTypes = ['normal', 'fast', 'tank', 'spitter', 'exploder', 'electric', 'stealth', 'giant', 'splitter', 'healer', 'berserker'];
        return allTypes[Math.floor(Math.random() * allTypes.length)];
    }
    
    getZombieLevelForLevel(gameLevel) {
        // 根据游戏关卡决定僵尸等级分布
        if (gameLevel <= 2) {
            // 前两关：主要是1级僵尸
            return Math.random() < 0.8 ? 1 : 2;
        } else if (gameLevel <= 4) {
            // 3-4关：1-2级僵尸，少量3级
            const rand = Math.random();
            if (rand < 0.5) return 1;
            if (rand < 0.8) return 2;
            return 3;
        } else if (gameLevel <= 6) {
            // 5-6关：1-3级僵尸混合
            const rand = Math.random();
            if (rand < 0.3) return 1;
            if (rand < 0.6) return 2;
            if (rand < 0.9) return 3;
            return 4;
        } else if (gameLevel <= 8) {
            // 7-8关：2-4级僵尸为主
            const rand = Math.random();
            if (rand < 0.2) return 2;
            if (rand < 0.5) return 3;
            if (rand < 0.8) return 4;
            return 5;
        } else if (gameLevel <= 10) {
            // 9-10关：高等级僵尸为主
            const rand = Math.random();
            if (rand < 0.1) return 2;
            if (rand < 0.3) return 3;
            if (rand < 0.6) return 4;
            return 5;
        } else if (gameLevel <= 12) {
            // 11-12关：引入6级僵尸
            const rand = Math.random();
            if (rand < 0.1) return 3;
            if (rand < 0.3) return 4;
            if (rand < 0.6) return 5;
            return 6;
        } else if (gameLevel <= 15) {
            // 13-15关：中高级僵尸
            const rand = Math.random();
            if (rand < 0.1) return 4;
            if (rand < 0.3) return 5;
            if (rand < 0.6) return 6;
            if (rand < 0.8) return 7;
            return 8;
        } else if (gameLevel <= 18) {
            // 16-18关：高级僵尸为主
            const rand = Math.random();
            if (rand < 0.1) return 5;
            if (rand < 0.2) return 6;
            if (rand < 0.4) return 7;
            if (rand < 0.6) return 8;
            if (rand < 0.8) return 9;
            return 10;
        } else {
            // 19-20关：终极高级僵尸
            const rand = Math.random();
            if (rand < 0.1) return 8;
            if (rand < 0.2) return 9;
            if (rand < 0.4) return 10;
            if (rand < 0.6) return 12;
            if (rand < 0.8) return 15;
            return 20; // 最高级别僵尸
        }
    }
    
    // 简单治疗粒子特效作为备用
    createSimpleHealParticles() {
        try {
            if (window.gameEngine && window.gameEngine.particles) {
                // 创建绿色治疗粒子
                for (let i = 0; i < 5; i++) {
                    window.gameEngine.particles.push({
                        x: this.x + (Math.random() - 0.5) * 20,
                        y: this.y + (Math.random() - 0.5) * 20,
                        vx: (Math.random() - 0.5) * 50,
                        vy: (Math.random() - 0.5) * 50,
                        life: 1000,
                        maxLife: 1000,
                        color: '#00FF00',
                        size: 3,
                        update: function(deltaTime) {
                            this.x += this.vx * deltaTime / 1000;
                            this.y += this.vy * deltaTime / 1000;
                            this.life -= deltaTime;
                            return this.life > 0;
                        },
                        render: function(ctx) {
                            const alpha = this.life / this.maxLife;
                            ctx.fillStyle = `rgba(0, 255, 0, ${alpha})`;
                            ctx.beginPath();
                            ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
                            ctx.fill();
                        }
                    });
                }
            }
        } catch (error) {
            console.warn('简单治疗粒子创建失败:', error);
        }
    }
    
    // 简单爆炸粒子特效作为备用 - 已优化
    createSimpleExplosionParticles() {
        // 禁用红色爆炸粒子效果 - 这是造成红色圆圈的主要源头
        return;
        /*
        try {
            if (window.gameEngine && window.gameEngine.particles) {
                // 优化的简单爆炸粒子
                const particleCount = 6; // 从8减少到6
                
                // 检查粒子数量限制
                if (window.gameEngine.particles.length > 40) {
                    return; // 跳过效果
                }
                
                for (let i = 0; i < particleCount; i++) {
                    const angle = (i / particleCount) * Math.PI * 2;
                    window.gameEngine.particles.push({
                        x: this.x,
                        y: this.y,
                        vx: Math.cos(angle) * 60, // 减少速度
                        vy: Math.sin(angle) * 60,
                        life: 500, // 减少生存时间
                        maxLife: 500,
                        color: '#FF4444',
                        size: 3, // 减小粒子大小
                        update: function(deltaTime) {
                            this.x += this.vx * deltaTime / 1000;
                            this.y += this.vy * deltaTime / 1000;
                            this.life -= deltaTime;
                            this.vx *= 0.96; // 更快减速
                            this.vy *= 0.96;
                            return this.life > 0;
                        },
                        render: function(ctx) {
                            const alpha = this.life / this.maxLife;
                            ctx.fillStyle = `rgba(255, 68, 68, ${alpha * 0.7})`;
                            ctx.beginPath();
                            ctx.arc(this.x, this.y, this.size * alpha, 0, Math.PI * 2);
                            ctx.fill();
                        }
                    });
                }
            }
        } catch (error) {
            console.warn('简单爆炸粒子创建失败:', error);
        }
        */
    }
    
    // === 新僵尸类型特殊能力方法 ===
    
    // 处理新僵尸类型的特殊能力更新
    updateSpecialAbilities(deltaTime, player) {
        if (!this.stats || !this.stats.special) return;
        
        const currentTime = Date.now();
        
        try {
            switch (this.stats.special) {
                case 'electric_attack':
                    this.updateElectricAttack(currentTime, player);
                    break;
                    
                case 'stealth_ability':
                    this.updateStealthAbility(currentTime);
                    break;
                    
                case 'berserker_rage':
                    this.updateBerserkerRage();
                    break;
                    
                case 'heal_others':
                    this.updateHealAbility(currentTime);
                    break;
            }
        } catch (error) {
            console.error('特殊能力更新失败:', error);
        }
    }
    
    // 电击攻击
    updateElectricAttack(currentTime, player) {
        if (!player || !this.stats || !this.stats.electricCooldown) return;
        
        if (!this.lastElectricAttack) this.lastElectricAttack = 0;
        
        if (currentTime - this.lastElectricAttack > this.stats.electricCooldown) {
            const distToPlayer = Math.sqrt(
                Math.pow(this.x - player.x, 2) + Math.pow(this.y - player.y, 2)
            );
            
            if (distToPlayer <= (this.stats.electricRange || 120)) {
                this.performElectricAttack(player);
                this.lastElectricAttack = currentTime;
            }
        }
    }
    
    performElectricAttack(player) {
        console.log('⚡ 电击僵尸发动电击攻击！');
        
        // 对玩家造成伤害
        if (player && typeof player.takeDamage === 'function' && this.stats && this.stats.electricDamage) {
            player.takeDamage(this.stats.electricDamage);
        }
        
        // 创建电击特效
        this.createElectricEffect();
    }
    
    createElectricEffect() {
        try {
            if (window.gameEngine && window.gameEngine.particles) {
                // 优化电击粒子效果 - 减少数量，提升性能
                const particleCount = 6; // 从10减少到6
                
                // 检查粒子数量限制
                if (window.gameEngine.particles.length > 30) {
                    console.log('⚠️ 粒子数量过多，简化电击效果');
                    return;
                }
                
                for (let i = 0; i < particleCount; i++) {
                    const angle = (Math.PI * 2 / particleCount) * i;
                    const distance = this.stats.electricRange * 0.7; // 稍微减小范围
                    
                    window.gameEngine.particles.push({
                        x: this.x + Math.cos(angle) * distance * Math.random(),
                        y: this.y + Math.sin(angle) * distance * Math.random(),
                        vx: (Math.random() - 0.5) * 60, // 减少速度
                        vy: (Math.random() - 0.5) * 60,
                        life: 300, // 减少生存时间
                        maxLife: 300,
                        color: '#00FFFF',
                        size: Math.random() * 3 + 1, // 减小粒子大小
                        update: function(deltaTime) {
                            this.x += this.vx * deltaTime / 1000;
                            this.y += this.vy * deltaTime / 1000;
                            this.life -= deltaTime;
                            return this.life > 0;
                        },
                        render: function(ctx) {
                            const alpha = this.life / this.maxLife;
                            ctx.fillStyle = `rgba(0, 255, 255, ${alpha * 0.7})`;
                            ctx.beginPath();
                            ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
                            ctx.fill();
                        }
                    });
                }
            }
        } catch (error) {
            console.error('创建电击特效失败:', error);
        }
    }
    
    // 隐身能力
    updateStealthAbility(currentTime) {
        if (!this.stats || !this.stats.stealthDuration || !this.stats.stealthCooldown) return;
        
        if (!this.stealthTimer) {
            this.stealthTimer = currentTime;
            this.isStealthed = false;
            this.alpha = 1;
        }
        
        const timeSinceLastToggle = currentTime - this.stealthTimer;
        const totalCycle = this.stats.stealthDuration + this.stats.stealthCooldown;
        
        if (timeSinceLastToggle >= totalCycle) {
            this.stealthTimer = currentTime;
        }
        
        // 更新隐身状态
        if (timeSinceLastToggle < this.stats.stealthDuration) {
            this.isStealthed = true;
            this.alpha = 0.3; // 半透明
        } else {
            this.isStealthed = false;
            this.alpha = 1;
        }
    }
    
    // 狂暴状态
    updateBerserkerRage() {
        if (!this.stats || !this.stats.maxSpeedMultiplier || !this.health || !this.maxHealth) return;
        
        const healthPercent = this.health / this.maxHealth;
        const rageMultiplier = 1 + (1 - healthPercent) * (this.stats.maxSpeedMultiplier - 1);
        
        // 更新速度（血量越低速度越快）
        this.currentSpeed = (this.stats.speed || this.speed || 80) * rageMultiplier;
        
        // 更新颜色（血量越低颜色越红）
        const redness = Math.floor(255 * (2 - rageMultiplier));
        this.currentColor = `rgb(220, ${redness}, ${redness})`;
    }
    
    // 治愈能力
    updateHealAbility(currentTime) {
        if (!this.stats || !this.stats.healCooldown) return;
        
        if (!this.lastHeal) this.lastHeal = 0;
        
        if (currentTime - this.lastHeal > this.stats.healCooldown) {
            this.performHealAbility();
            this.lastHeal = currentTime;
        }
    }
    
    performHealAbility() {
        if (!this.stats || !this.stats.healRange || !this.stats.healAmount) return;
        
        try {
            if (window.gameEngine && window.gameEngine.zombies) {
                let healed = 0;
                
                window.gameEngine.zombies.forEach(zombie => {
                    if (zombie !== this && zombie.health < zombie.maxHealth) {
                        const distance = Math.sqrt(
                            Math.pow(this.x - zombie.x, 2) + Math.pow(this.y - zombie.y, 2)
                        );
                        
                        if (distance <= this.stats.healRange) {
                            const healAmount = Math.min(
                                this.stats.healAmount,
                                zombie.maxHealth - zombie.health
                            );
                            zombie.health += healAmount;
                            healed++;
                            
                            // 治愈特效
                            this.createHealEffect(zombie);
                        }
                    }
                });
                
                if (healed > 0) {
                    console.log(`💚 治愈僵尸治愈了${healed}只僵尸`);
                }
            }
        } catch (error) {
            console.error('治愈能力执行失败:', error);
        }
    }
    
    createHealEffect(target) {
        try {
            if (window.gameEngine && window.gameEngine.particles) {
                // 优化治愈粒子效果 - 减少数量，提升性能
                const particleCount = 3; // 从5减少到3
                
                // 检查粒子数量限制
                if (window.gameEngine.particles.length > 25) {
                    return; // 粒子过多时跳过治愈效果
                }
                
                for (let i = 0; i < particleCount; i++) {
                    window.gameEngine.particles.push({
                        x: target.x + (Math.random() - 0.5) * 30, // 减小范围
                        y: target.y + (Math.random() - 0.5) * 30,
                        vx: 0,
                        vy: -Math.random() * 30 - 15, // 减少速度
                        life: 600, // 减少生存时间
                        maxLife: 600,
                        color: '#32CD32',
                        size: Math.random() * 4 + 2, // 减小粒子大小
                        update: function(deltaTime) {
                            this.x += this.vx * deltaTime / 1000;
                            this.y += this.vy * deltaTime / 1000;
                            this.life -= deltaTime;
                            return this.life > 0;
                        },
                        render: function(ctx) {
                            const alpha = this.life / this.maxLife;
                            ctx.fillStyle = `rgba(50, 205, 50, ${alpha * 0.8})`;
                            ctx.beginPath();
                            ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
                            ctx.fill();
                        }
                    });
                }
            }
        } catch (error) {
            console.error('创建治愈特效失败:', error);
        }
    }
    
    // 扩展die方法以处理死亡特殊能力
    die() {
        // 处理死亡时的特殊能力
        if (this.stats && this.stats.special) {
            try {
                switch (this.stats.special) {
                    case 'explosion_on_death':
                        this.explodeOnDeath();
                        break;
                        
                    case 'split_on_death':
                        this.splitOnDeath();
                        break;
                }
            } catch (error) {
                console.error('死亡特殊能力执行失败:', error);
            }
        }
        
        // 调用原始死亡逻辑
        try {
            // 移除自己
            if (window.gameEngine && window.gameEngine.zombies) {
                const index = window.gameEngine.zombies.indexOf(this);
                if (index > -1) {
                    window.gameEngine.zombies.splice(index, 1);
                }
            }
            
            // 添加经验和分数
            if (window.player) {
                if (typeof window.player.addExperience === 'function') {
                    window.player.addExperience(this.expReward);
                }
                if (typeof window.player.addScore === 'function') {
                    window.player.addScore(this.calculateScore());
                }
            }
        } catch (error) {
            console.error('僵尸死亡处理失败:', error);
        }
    }
    
    // 死亡爆炸
    explodeOnDeath() {
        if (!this.stats || !this.stats.explosionRadius || !this.stats.explosionDamage) return;
        
        console.log('💥 爆炸僵尸死亡爆炸！');
        
        try {
            // 对周围单位造成伤害
            if (window.player) {
                const distToPlayer = Math.sqrt(
                    Math.pow(this.x - window.player.x, 2) + Math.pow(this.y - window.player.y, 2)
                );
                
                if (distToPlayer <= this.stats.explosionRadius) {
                    if (typeof window.player.takeDamage === 'function') {
                        window.player.takeDamage(this.stats.explosionDamage);
                        console.log('💥 玩家受到爆炸伤害！');
                    }
                }
            }
            
            // 对其他僵尸造成伤害
            if (window.gameEngine && window.gameEngine.zombies) {
                window.gameEngine.zombies.forEach(zombie => {
                    if (zombie !== this) {
                        const distance = Math.sqrt(
                            Math.pow(this.x - zombie.x, 2) + Math.pow(this.y - zombie.y, 2)
                        );
                        
                        if (distance <= this.stats.explosionRadius) {
                            if (typeof zombie.takeDamage === 'function') {
                                zombie.takeDamage(this.stats.explosionDamage * 0.5); // 对僵尸伤害减半
                            }
                        }
                    }
                });
            }
            
            // 创建爆炸特效
            this.createExplosionEffect();
            
        } catch (error) {
            console.error('爆炸效果执行失败:', error);
        }
    }
    
    createExplosionEffect() {
        // 彻底禁用爆炸粒子效果 - 这是造成红色嵌套圆圈的主要源头
        return;
        /*
        try {
            if (window.gameEngine && window.gameEngine.particles) {
                // 优化后的爆炸粒子 - 减少数量和生存时间，提升性能
                const particleCount = 8; // 从15减少到8
                const maxParticles = 50; // 全局粒子数量限制
                
                // 检查当前粒子数量，避免过多粒子影响性能
                if (window.gameEngine.particles.length > maxParticles) {
                    console.log('⚠️ 粒子数量过多，跳过爆炸效果');
                    return;
                }
                
                for (let i = 0; i < particleCount; i++) {
                    const angle = (Math.PI * 2 * i) / particleCount;
                    const speed = Math.random() * 80 + 40; // 减少速度：从100-300降到40-120
                    
                    window.gameEngine.particles.push({
                        x: this.x,
                        y: this.y,
                        vx: Math.cos(angle) * speed,
                        vy: Math.sin(angle) * speed,
                        life: Math.random() * 600 + 400, // 大幅减少生存时间：从1-3秒降到0.4-1秒
                        maxLife: Math.random() * 600 + 400,
                        color: ['#FF4500', '#FF6347', '#FFD700'][Math.floor(Math.random() * 3)], // 减少一种颜色
                        size: Math.random() * 4 + 2, // 减小粒子大小：从4-12降到2-6
                        update: function(deltaTime) {
                            this.x += this.vx * deltaTime / 1000;
                            this.y += this.vy * deltaTime / 1000;
                            this.life -= deltaTime;
                            this.vx *= 0.95; // 更快的减速
                            this.vy *= 0.95;
                            return this.life > 0;
                        },
                        render: function(ctx) {
                            const alpha = Math.max(0, this.life / this.maxLife);
                            // 简化颜色处理，提升性能
                            if (this.color.includes('#')) {
                                ctx.fillStyle = this.color;
                                ctx.globalAlpha = alpha * 0.8; // 降低不透明度
                            } else {
                                ctx.fillStyle = this.color.replace(')', `, ${alpha * 0.8})`).replace('rgb', 'rgba');
                            }
                            
                            ctx.beginPath();
                            ctx.arc(this.x, this.y, this.size * alpha, 0, Math.PI * 2);
                            ctx.fill();
                            ctx.globalAlpha = 1; // 恢复全局透明度
                        }
                    });
                }
        
                // 创建一个简单的爆炸闪光效果，替代大量粒子 - 已禁用圆圈效果
                // this.createExplosionFlash();
            }
        } catch (error) {
            console.error('创建爆炸粒子失败:', error);
        }
        */
    }
    
    // 简单的爆炸闪光效果，替代过多粒子 - 已彻底禁用圆圈效果
    createExplosionFlash() {
        // 彻底禁用爆炸闪光效果 - 这可能是造成红色嵌套圆圈的源头
        return;
        /*
        try {
            if (window.gameEngine && window.gameEngine.particles) {
                // 添加一个快速闪光效果
                window.gameEngine.particles.push({
                    x: this.x,
                    y: this.y,
                    vx: 0,
                    vy: 0,
                    life: 200, // 仅持续0.2秒
                    maxLife: 200,
                    color: '#FFFF00',
                    size: this.stats.explosionRadius * 0.8, // 基于爆炸范围的闪光
                    update: function(deltaTime) {
                        this.life -= deltaTime;
                        return this.life > 0;
                    },
                    render: function(ctx) {
                        const alpha = this.life / this.maxLife;
                        ctx.save();
                        ctx.globalAlpha = alpha * 0.3; // 半透明闪光
                        ctx.fillStyle = this.color;
                        ctx.beginPath();
                        ctx.arc(this.x, this.y, this.size * alpha, 0, Math.PI * 2);
                        ctx.fill();
                        ctx.restore();
                    }
                });
            }
        } catch (error) {
            console.error('创建爆炸闪光失败:', error);
        }
        */
    }
    
    // 死亡分裂
    splitOnDeath() {
        if (!this.stats || !this.stats.splitCount || !this.stats.splitType) return;
        
        console.log('🔄 分裂僵尸死亡分裂！');
        
        try {
            if (window.gameEngine && window.gameEngine.zombies && typeof Zombie !== 'undefined') {
                for (let i = 0; i < this.stats.splitCount; i++) {
                    const angle = (Math.PI * 2 / this.stats.splitCount) * i;
                    const distance = 40;
                    
                    const splitX = this.x + Math.cos(angle) * distance;
                    const splitY = this.y + Math.sin(angle) * distance;
                    
                    // 创建小僵尸（等级降低）
                    const splitZombie = new Zombie(splitX, splitY, this.stats.splitType, Math.max(1, this.level - 1));
                    splitZombie.health = Math.floor(splitZombie.health * 0.6); // 分裂后血量减少
                    splitZombie.maxHealth = splitZombie.health;
                    if (splitZombie.radius) {
                        splitZombie.radius = Math.floor(splitZombie.radius * 0.8); // 体型稍小
                    }
                    
                    window.gameEngine.zombies.push(splitZombie);
                }
                
                console.log(`🔄 分裂产生${this.stats.splitCount}只小僵尸`);
            }
        } catch (error) {
            console.error('分裂效果执行失败:', error);
        }
    }
}